Quantitative Trading Strategy with Python
Kannan Singaravelu, CQF
@kannan_fno | kannansingaravelu.com | github.com/kannansingaravelu
© 2020. All rights reserved.
Agenda¶
- Overview of quant workflow
- Trading strategy workflow
- Backtesting
- Performance & risk metrics
About me¶
- Data Science Enthusiast
- Quant Researcher and Derivatives Structurer
- Alumnus of of Paul Wilmott’s Certificate in Quantitative Finance
- Alumnus of WorldQuant University’s Applied Data Science
- B.E. (Mech), M.B.A with more than 16 years of experience in financial industry
- Strong advocate of Financial Data Science
Quantitative Trading¶
Quantitative trading consists of trading strategies based on quantitative analysis that rely on mathematics and statistics to identify trading opportunities. Quantitative strategies can be broadly classified into a) Trend Following and b) Mean Reversion.
Almost 85% of CTA returns can be explained by simple trend following. Momentum strategies are by far the most popular systematic strategies used by hedge fund managers. Pair Trading strategies are popular version of statistical arbitrage that employ mean reversion models to capture short term mispricing.
Quantitative strategies involve heavy use of quantitative and computational approaches to trading.
Ideation¶
While moving average models are the ‘hello world’ of trend following strategies, in the era of machine learning, I try to approach it purely from a quantitative perspective where all signals were based on raw price data and its statistical properties.
The strategy is to buy and sell the Indian equity benchmark Nifty Index when the trend score is above/below a certain threshold.
Data Mining¶
Data can be mined from Bloomberg, Broker's API, Data Vendors and Refinitiv's Eikon API. Nifty futures 1-Min data from August 2010 to August 2019 was used for this exercise.
Importing Required Libraries¶
We'll import the required libraries that we'll use.
# Import the pandas library
import pandas as pd
# Import the numpy library
import numpy as np
# Import trend score function from the pyalgo library
from pyalgo.tseries import trend_score
# Import cufflinks library for data visualization
import cufflinks as cf
cf.set_config_file(offline=True)
# Import financial function library for performance metrics
import ffn
# Ignore warnings
import warnings
warnings.filterwarnings("ignore")
Reading a CSV File¶
We'll read historical intraday data of NIFTY Index.
# Retrieve Data from text file
df = pd.read_csv('data/NIFTY-I-NEW.txt', sep=',', header=None)
df.head()
Data Wrangling¶
Now, we will resample the data to 5-min interval and manipulate it to generate trade signals.
# Resample to 5-Min
df = (
df.set_index('datetime')
.drop('date',axis=1)
.drop('time',axis=1)
.resample('5min')
.agg({'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last', 'volume': 'sum'})
.dropna()
)
df.head()
# Plot Index Price
df['close'].iplot(title='Nifty Index from 2010-2019')
Strategy and Trading Rule Definition¶
We'll define the strategy and rules based on which the trade signals would be generated.
Trend Indicator¶
Trend score is a measure of how strongly the time series is trending. Consider a time series of length $n$ with ordered components $\{x_i\}$ for $i=1,...,n$
A score between -1 and +1 can be associated to $\{x_i\}$ based on how strongly the time series is trending. Scores near $\pm$1 will be associated with strongly positively/negatively trending series, and scores near 0 will be assigned to series that do not exhibit trending characteristics. Trend Score determines the trading signal based on the statistical strength of the realized return:
$$TrendScore_i \left\{ \begin{array} {ll} +1 &\mbox{if } score>+1 \\ score & otherwise \\ -1 &\mbox{if }score<-1 \end{array} \right.$$When the absolute value of our trend score is greater than 1, the trend is highly statistically significant, so the strategy puts 100% exposure to the asset.
Trading Rule¶
Enter (Buy) when the trend score is above a specific value. Exit (Sell) the position when the trend score falls below a specific value. The trend duration is specified by another parameter.
# Apply Trend Score
df['tscore'] = df['close'].rolling(60).apply(trend_score, raw=True).fillna(0)
# Check the last five values
df['tscore'].tail()
Validation (backtesting)¶
Backtesting is a process of applying your trading strategy to historical data and stimulate how they would have performed in the past without actually risking your capital.
Vectorized Backtesting
There are several ways to backtest a strategy on historical data. In this exercise, we'll demonstrate using vectorisation.Why Vectorize?
The most obvious way to run a backtest over historical data is to create a loop and feed price/signal information one-by-one to a decision engine that determines whether we buy, sell or do nothing based on, say, price/signal action. But, this can be very expensive and can be painfully slow as we were to run 166k data points with different parameters.Backtesting Assumptions
- Backtesting assumes zero friction and trades were fully collateralized (meaning returns were calculated on the notional value of the contract and not on margin deployed for the trade).
- Signals were not optimized for this exercise and no short selling was allowed.
- Trade was entered at the close price of the period.
- The position was held until a sell signal is triggered.
- Trade was left untouched and all statistics were recorded between entry and exit levels.
Signal Generation
# Define signal based on trend score
df['signal'] = np.where(df['tscore']==1,1,0)
df['signal'] = np.where(df['tscore']<0.8,0,df['signal'])
# Calculate strategy return
df['returns'] = (df['signal'].shift(1) * df['close'].pct_change()).fillna(0)
# Construct equity curve
df['eq_curve'] = 1e5 * (1+df['returns']).cumprod()
# Plot Strategy Curve
df[['close', 'eq_curve']].normalize().iplot(title='Strategy Equity Curve')